{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先导入一些用到的库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "先来看看数据长什么样子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-b0ffac263758>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From c:\\users\\donpi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From c:\\users\\donpi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\users\\donpi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\users\\donpi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000,)\n",
      "(5000, 784)\n",
      "(5000,)\n",
      "(10000, 784)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\")\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到images里面有数量不等的图片，每张图片是28x28长度的一个一维向量， 所以用的时候需要先给它还原成28x28的二维图片。labels中则是图片对应的数字的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4,4, idx+1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(mnist.train.labels[idx]))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28,28)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "接下来，定义用于训练的网络，首先定义网络的输入。\n",
    "\n",
    "这里我们直接使用上面的数据作为输入，所以定义两个placeholder分别用于图像和lable数据，另外，定义一个float类型的变量用于设置学习率。\n",
    "\n",
    "为了让网络更高效的运行，多个数据会被组织成一个batch送入网络，两个placeholder的第一个维度就是batchsize，因为我们这里还没有确定batchsize，所以第一个维度留空。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\donpi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n"
     ]
    }
   ],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784])\n",
    "y = tf.placeholder(\"int64\", [None])\n",
    "learning_rate = tf.placeholder(\"float\")\n",
    "\n",
    "def initialize(shape, stddev=0.1):\n",
    "  return tf.truncated_normal(shape, stddev=0.1)\n",
    "\n",
    "L1_units_count = 1000\n",
    "\n",
    "W_1 = tf.Variable(initialize([784, L1_units_count]))\n",
    "b_1 = tf.Variable(initialize([L1_units_count]))\n",
    "logits_1 = tf.matmul(x, W_1) + b_1\n",
    "output_1 = tf.nn.relu(logits_1)\n",
    "\n",
    "L2_units_count = 10 \n",
    "W_2 = tf.Variable(initialize([L1_units_count, L2_units_count]))\n",
    "b_2 = tf.Variable(initialize([L2_units_count]))\n",
    "logits_2 = tf.matmul(output_1, W_2) + b_2  \n",
    "\n",
    "logits = logits_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "接下来定义loss和用于优化网络的优化器。loss计算使用了sparse_softmax_cross_entropy_with_logits, 这样做的好处是labels可以不用手动做one_hot省了一些麻烦。这里使用了sgd优化器，学习率为可以根据需要设定。\n",
    "\n",
    "试试看，增大减小学习率，换个优化器再进行训练会发生什么。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "\n",
    "REGULARIZATION_RATE = 0.0001  # 正则化项在损失函数中的系数\n",
    "  # 设置正则化方法\n",
    "regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)  # 定义L2正则化损失函数\n",
    "regularization = regularizer(W_1) + regularizer(W_2)  # 计算模型的正则化损失\n",
    "cross_entropy_loss = cross_entropy_loss + regularization \n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=learning_rate).minimize(cross_entropy_loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "需要注意的是，上面的网络，最后输出的是未经softmax的原始logits，而不是概率分布， 要想看到概率分布，还需要做一下softmax。\n",
    "\n",
    "将输出的结果与正确结果进行对比，即可得到我们的网络输出结果的准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(pred, 1), y)\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "saver用于保存或恢复训练的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "trainig_step = 10000\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "以上定义的所有操作，均为计算图，也就是仅仅是定义了网络的结构，实际需要运行的话，还需要创建一个session，并将数据填入网络中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.765845, the validation accuracy is 0.8898\n",
      "after 200 training steps, the loss is 0.365383, the validation accuracy is 0.9212\n",
      "after 300 training steps, the loss is 0.642116, the validation accuracy is 0.9426\n",
      "after 400 training steps, the loss is 0.427637, the validation accuracy is 0.9312\n",
      "after 500 training steps, the loss is 0.352199, the validation accuracy is 0.9486\n",
      "after 600 training steps, the loss is 0.402917, the validation accuracy is 0.95\n",
      "WARNING:tensorflow:From c:\\users\\donpi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:966: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps, the loss is 0.347799, the validation accuracy is 0.9618\n",
      "after 800 training steps, the loss is 0.441962, the validation accuracy is 0.9594\n",
      "after 900 training steps, the loss is 0.408791, the validation accuracy is 0.9612\n",
      "after 1000 training steps, the loss is 0.426745, the validation accuracy is 0.9648\n",
      "after 1100 training steps, the loss is 0.3642, the validation accuracy is 0.9666\n",
      "after 1200 training steps, the loss is 0.509911, the validation accuracy is 0.9676\n",
      "after 1300 training steps, the loss is 0.763277, the validation accuracy is 0.9668\n",
      "after 1400 training steps, the loss is 0.470778, the validation accuracy is 0.9694\n",
      "after 1500 training steps, the loss is 0.314669, the validation accuracy is 0.9722\n",
      "after 1600 training steps, the loss is 0.442198, the validation accuracy is 0.97\n",
      "after 1700 training steps, the loss is 0.327451, the validation accuracy is 0.9726\n",
      "after 1800 training steps, the loss is 0.3131, the validation accuracy is 0.973\n",
      "after 1900 training steps, the loss is 0.382372, the validation accuracy is 0.9738\n",
      "after 2000 training steps, the loss is 0.324605, the validation accuracy is 0.9742\n",
      "after 2100 training steps, the loss is 0.344912, the validation accuracy is 0.975\n",
      "after 2200 training steps, the loss is 0.334231, the validation accuracy is 0.9756\n",
      "after 2300 training steps, the loss is 0.317264, the validation accuracy is 0.9726\n",
      "after 2400 training steps, the loss is 0.317183, the validation accuracy is 0.9722\n",
      "after 2500 training steps, the loss is 0.336944, the validation accuracy is 0.9748\n",
      "after 2600 training steps, the loss is 0.337635, the validation accuracy is 0.9752\n",
      "after 2700 training steps, the loss is 0.366669, the validation accuracy is 0.9726\n",
      "after 2800 training steps, the loss is 0.288292, the validation accuracy is 0.9726\n",
      "after 2900 training steps, the loss is 0.357831, the validation accuracy is 0.9774\n",
      "after 3000 training steps, the loss is 0.319647, the validation accuracy is 0.9768\n",
      "after 3100 training steps, the loss is 0.292681, the validation accuracy is 0.9778\n",
      "after 3200 training steps, the loss is 0.423651, the validation accuracy is 0.9772\n",
      "after 3300 training steps, the loss is 0.386584, the validation accuracy is 0.9764\n",
      "after 3400 training steps, the loss is 0.274662, the validation accuracy is 0.975\n",
      "after 3500 training steps, the loss is 0.292687, the validation accuracy is 0.9766\n",
      "after 3600 training steps, the loss is 0.317203, the validation accuracy is 0.9782\n",
      "after 3700 training steps, the loss is 0.290643, the validation accuracy is 0.9748\n",
      "after 3800 training steps, the loss is 0.358048, the validation accuracy is 0.9812\n",
      "after 3900 training steps, the loss is 0.307372, the validation accuracy is 0.9782\n",
      "after 4000 training steps, the loss is 0.309049, the validation accuracy is 0.9784\n",
      "after 4100 training steps, the loss is 0.262072, the validation accuracy is 0.9786\n",
      "after 4200 training steps, the loss is 0.2935, the validation accuracy is 0.979\n",
      "after 4300 training steps, the loss is 0.286309, the validation accuracy is 0.9834\n",
      "after 4400 training steps, the loss is 0.395288, the validation accuracy is 0.9778\n",
      "after 4500 training steps, the loss is 0.272961, the validation accuracy is 0.9776\n",
      "after 4600 training steps, the loss is 0.257584, the validation accuracy is 0.9786\n",
      "after 4700 training steps, the loss is 0.256887, the validation accuracy is 0.9786\n",
      "after 4800 training steps, the loss is 0.25576, the validation accuracy is 0.98\n",
      "after 4900 training steps, the loss is 0.25927, the validation accuracy is 0.9774\n",
      "after 5000 training steps, the loss is 0.302338, the validation accuracy is 0.9794\n",
      "after 5100 training steps, the loss is 0.302782, the validation accuracy is 0.978\n",
      "after 5200 training steps, the loss is 0.25374, the validation accuracy is 0.9824\n",
      "after 5300 training steps, the loss is 0.256001, the validation accuracy is 0.9806\n",
      "after 5400 training steps, the loss is 0.259568, the validation accuracy is 0.9792\n",
      "after 5500 training steps, the loss is 0.24818, the validation accuracy is 0.9792\n",
      "after 5600 training steps, the loss is 0.265616, the validation accuracy is 0.98\n",
      "after 5700 training steps, the loss is 0.257872, the validation accuracy is 0.978\n",
      "after 5800 training steps, the loss is 0.252758, the validation accuracy is 0.981\n",
      "after 5900 training steps, the loss is 0.243638, the validation accuracy is 0.982\n",
      "after 6000 training steps, the loss is 0.263686, the validation accuracy is 0.9782\n",
      "after 6100 training steps, the loss is 0.239513, the validation accuracy is 0.9816\n",
      "after 6200 training steps, the loss is 0.243305, the validation accuracy is 0.9836\n",
      "after 6300 training steps, the loss is 0.292751, the validation accuracy is 0.9838\n",
      "after 6400 training steps, the loss is 0.237106, the validation accuracy is 0.9844\n",
      "after 6500 training steps, the loss is 0.237264, the validation accuracy is 0.985\n",
      "after 6600 training steps, the loss is 0.289419, the validation accuracy is 0.9844\n",
      "after 6700 training steps, the loss is 0.249748, the validation accuracy is 0.9842\n",
      "after 6800 training steps, the loss is 0.243433, the validation accuracy is 0.983\n",
      "after 6900 training steps, the loss is 0.283387, the validation accuracy is 0.9838\n",
      "after 7000 training steps, the loss is 0.247231, the validation accuracy is 0.9836\n",
      "after 7100 training steps, the loss is 0.244457, the validation accuracy is 0.9842\n",
      "after 7200 training steps, the loss is 0.2396, the validation accuracy is 0.983\n",
      "after 7300 training steps, the loss is 0.298261, the validation accuracy is 0.9848\n",
      "after 7400 training steps, the loss is 0.235792, the validation accuracy is 0.984\n",
      "after 7500 training steps, the loss is 0.263792, the validation accuracy is 0.9842\n",
      "after 7600 training steps, the loss is 0.253517, the validation accuracy is 0.9844\n",
      "after 7700 training steps, the loss is 0.251894, the validation accuracy is 0.984\n",
      "after 7800 training steps, the loss is 0.233671, the validation accuracy is 0.9844\n",
      "after 7900 training steps, the loss is 0.233054, the validation accuracy is 0.984\n",
      "after 8000 training steps, the loss is 0.234811, the validation accuracy is 0.9856\n",
      "after 8100 training steps, the loss is 0.237117, the validation accuracy is 0.985\n",
      "after 8200 training steps, the loss is 0.23169, the validation accuracy is 0.985\n",
      "after 8300 training steps, the loss is 0.237191, the validation accuracy is 0.9842\n",
      "after 8400 training steps, the loss is 0.285863, the validation accuracy is 0.9844\n",
      "after 8500 training steps, the loss is 0.245301, the validation accuracy is 0.9844\n",
      "after 8600 training steps, the loss is 0.232099, the validation accuracy is 0.984\n",
      "after 8700 training steps, the loss is 0.249116, the validation accuracy is 0.9852\n",
      "after 8800 training steps, the loss is 0.231427, the validation accuracy is 0.9846\n",
      "after 8900 training steps, the loss is 0.228762, the validation accuracy is 0.9846\n",
      "after 9000 training steps, the loss is 0.236937, the validation accuracy is 0.9856\n",
      "after 9100 training steps, the loss is 0.24601, the validation accuracy is 0.9854\n",
      "after 9200 training steps, the loss is 0.23518, the validation accuracy is 0.9852\n",
      "after 9300 training steps, the loss is 0.228071, the validation accuracy is 0.9848\n",
      "after 9400 training steps, the loss is 0.252792, the validation accuracy is 0.985\n",
      "after 9500 training steps, the loss is 0.226595, the validation accuracy is 0.9828\n",
      "after 9600 training steps, the loss is 0.234743, the validation accuracy is 0.9846\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 9700 training steps, the loss is 0.233963, the validation accuracy is 0.9834\n",
      "after 9800 training steps, the loss is 0.227984, the validation accuracy is 0.9836\n",
      "after 9900 training steps, the loss is 0.225103, the validation accuracy is 0.9834\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9822\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels}\n",
    "    \n",
    "    lr = 0.3\n",
    "    for i in range(trainig_step):\n",
    "        if i > 6000 :\n",
    "            lr = 0.1\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss = sess.run(\n",
    "            [optimizer, cross_entropy_loss],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                learning_rate: lr\n",
    "            })\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "下面，用我们训练的模型做一个测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\users\\donpi\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-9900\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16]\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(mnist.test.labels[idx],\n",
    "                                                  order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
